Summary

This PR enables nogil support for most types of methods in autowrap-generated code. When a method is marked with nogil in the PXD file (e.g., void process() nogil), the generated wrapper will release Python's Global Interpreter Lock (GIL) before calling into C++, allowing true parallelism.

Key Changes

• ConversionProvider API change: input_conversion() now returns a 4-tuple (code, call_as, cleanup, decl) where decl is a tuple (declaration, call_expression) for split declaration in nogil contexts
• call_method() signature: Added with_cdef parameter to control whether to include cdef (not allowed inside nogil: blocks)
• CodeGenerator: Updated to handle the new return values and generate proper nogil-compatible code
• Cython requirement: Updated to >=3.1 for improved nogil support

Updated Converters

All TypeConverter classes now support nogil:

• Primitive types (int, float, bool, char, etc.)
• String types (libcpp_string, const_char*, string_view)
• Container types (vector, map, set, list, deque, pair)
• C++17 types (optional, unordered_map, unordered_set)
• Wrapped class types
• Enum types

nogil + OpenMP Thread Interaction Analysis

When a nogil-marked method (e.g., in pyOpenMS) internally uses OpenMP for parallelism:

How It Works

1. GIL is released before entering the C++ code via with nogil: block
2. OpenMP threads spawn inside the C++ library
3. All OpenMP threads execute without competing for Python's GIL
4. Threads complete, control returns
5. GIL is reacquired when leaving the nogil block

Safety Considerations

Example Flow

Python: call pyopenms.method()
  └─ Cython: "with nogil:" releases GIL
       └─ C++ code runs
            └─ #pragma omp parallel spawns threads
                 └─ All threads work without GIL contention
            └─ OpenMP threads complete
       └─ Returns to Cython
  └─ GIL reacquired
Python: continues

Bottom Line

This is safe and beneficial for libraries like OpenMS that use OpenMP internally:

• The GIL doesn't block OpenMP threads
• OpenMS's OpenMP code is pure C++ (no Python callbacks)
• Other Python threads can run while the C++ library processes data
• True multi-core parallelism is achieved

Test Plan

• All existing tests pass (165 passed, 1 skipped due to environment)
• C++17 STL containers test passes (optional, string_view, unordered_map, unordered_set)
• GIL testing with gil_testing.hpp verifies GIL is properly released

References

• Cython Parallelism Guide
• Cython and the GIL